package com.ylfstu.innerclass;

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.method();
    }
}

class Outer02 {
    private int n1 = 99;

    public void method() {
        //1.需求：想使用IA接口，并创建对象
        //2.传统方式是写一个类，实现该接口，并创建对象
        //3.需求是Tiger类只使用一次，后面不再使用
        //4.可以使用匿名内部类
        /**
         class Outer02$1 implements IA{
        @Override public void cry() {
        System.out.println("老虎叫...");
        }
        }
         **/
        //5.tiger的编译类型 IA
        //6.tiger的运行类型 就是匿名内部类 Outer02$1
        //7.jdk底层在创建匿名内部类 Outer02$1 ，马上就创建了Outer$1实例，并且把字体返回给 tiger
        //8.匿名内部类使用一次就不能再使用
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫...");
            }
        };
        System.out.println("tiger的运行类型=" + tiger.getClass());
        tiger.cry();

        //1.编译类型 Father
        //2.运行类型 Outer02$2
        //3.底层会创建匿名内部类
        /**
         *      class Outer02$2 extends Father{
         *
         *      }
         */
        //4.同时也直接返回了 匿名内部类 Outer02$2的对象
        //5.注意参数列表
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型" + father.getClass());
        father.test();

        //基于抽象类的匿名内部类
        Animal animal = new Animal() {
            @Override
            void test() {
                System.out.println("小狗汪汪汪...");
            }
        };
        animal.test();
    }
}

abstract class Animal {
    abstract void test();
}

interface IA {
    public void cry();
}

class Father {
    public Father(String name) {
        System.out.println("接收到name=" + name);
    }

    public void test() {

    }
}